package org.data.replay.controller;

import cn.hutool.core.util.ObjectUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.data.replay.common.Result;
import org.data.replay.dto.DataPoint;
import org.data.replay.dto.FaultResultModel;
import org.data.replay.dto.MeasurementResultDTO;
import org.data.replay.dto.ParameterDTO;
import org.data.replay.dto.QueryDataDTO;
import org.data.replay.service.DataReplayService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 数据回放控制器 提供设备查询、参数查询和数据查询接口
 *
 * @author DataReplay
 */
@Api(tags = "数据回放接口")
@RestController
@RequestMapping("/datareplay")
public class DataReplayController {
    
    @Autowired
    private DataReplayService dataReplayService;
    
    /**
     * 查询设备列表（下拉） GET /api/unitCode/list
     *
     * @return 设备编号列表
     */
    @ApiOperation(value = "查询设备列表", notes = "获取所有设备编号列表，用于下拉选择")
    @GetMapping("/list")
    public Result<List<String>> getEquipmentList() {
        try {
            List<String> equipmentList = dataReplayService.queryEquipmentList();
            return Result.success(equipmentList);
        } catch (Exception e) {
            return Result.error("查询设备列表失败: " + e.getMessage());
        }
    }
    
    /**
     * 根据设备编号获取标参（左侧导航栏） GET /api/unitCode/parameters?equipmentCode=xxx
     *
     * @param equipmentCode 设备编号（通用命名，适用于机组编号、发动机编号等）
     * @return 参数列表
     */
    @ApiOperation(value = "根据设备编号查询参数", notes = "根据设备编号获取标准参数列表，用于左侧导航栏显示")
    @GetMapping("/parameters")
    public Result<List<ParameterDTO>> getParametersByEquipment(@RequestParam String equipmentCode) {
        try {
            // 参数校验
            if (equipmentCode == null || equipmentCode.trim().isEmpty()) {
                return Result.badRequest("设备编号不能为空");
            }
            
            List<ParameterDTO> parameters = dataReplayService.queryParametersByEquipment(equipmentCode.trim());
            return Result.success(parameters);
        } catch (Exception e) {
            return Result.error("查询参数失败: " + e.getMessage());
        }
    }
    
    /**
     * 勾选参数查数据 POST /api/unitCode/queryData
     *
     * @param request 查询数据请求
     * @return 数据点列表
     */
    @ApiOperation(value = "查询数据", notes = "根据选中的参数、时间范围等条件查询数据")
    @PostMapping("/queryData")
    public Result<Map<String, List<DataPoint>>> queryData(@RequestBody QueryDataDTO request) {
        try {
            // todo 参数校验
            if (ObjectUtil.isEmpty(request.getParams())) {
                return Result.ok(new HashMap<>());
            }
            if (ObjectUtil.isEmpty(request.getStartTime())) {
                return Result.error("开始时间不能为空", new HashMap<>());
            }
            if (ObjectUtil.isEmpty(request.getEndTime())) {
                return Result.error("结束时间不能为空", new HashMap<>());
            }
            
            // 设置默认采样点数
            if (request.getSample() == null || request.getSample() <= 0) {
                request.setSample(500);
            }
            
            Map<String, List<DataPoint>> dataPoints = dataReplayService.queryData(request);
            return Result.success(dataPoints);
        } catch (Exception e) {
            return Result.error("查询数据失败: " + e.getMessage());
        }
    }
    
    /**
     * 查询测量数据 POST /datareplay/queryMeasurement 计算指定时间范围内参数的统计信息（最大值、最小值、平均值、波动值等）
     *
     * @param request 查询测量数据请求（与queryData接口入参保持一致）
     * @return 测量结果列表
     */
    @ApiOperation(value = "查询测量数据", notes = "根据设备编号、时间范围和参数列表查询测量数据，返回统计信息")
    @PostMapping("/calculateMeasurement")
    public Result<Map<String, MeasurementResultDTO>> queryMeasurement(@RequestBody QueryDataDTO request) {
        try {
            // 参数校验
            if (request.getUnitCode() == null || request.getUnitCode().trim().isEmpty()) {
                return Result.badRequest("设备编号不能为空");
            }
            if (request.getStartTime() == null || request.getStartTime().trim().isEmpty()) {
                return Result.badRequest("开始时间不能为空");
            }
            if (request.getEndTime() == null || request.getEndTime().trim().isEmpty()) {
                return Result.badRequest("结束时间不能为空");
            }
            
            Map<String, MeasurementResultDTO> measurementResults = dataReplayService.queryMeasurement(request);
            return Result.success(measurementResults);
        } catch (Exception e) {
            return Result.error("查询测量数据失败: " + e.getMessage());
        }
    }
    
    /**
     * 查询故障信息 GET /datareplay/queryFaultInfo?unitCode=xxx&startTime=xxx&endTime=xxx
     *
     * @param unitCode  设备编号（必填）
     * @param startTime 开始时间（必填，格式：yyyy-MM-dd HH:mm:ss）
     * @param endTime   结束时间（必填，格式：yyyy-MM-dd HH:mm:ss）
     * @return 故障信息列表
     */
    @ApiOperation(value = "查询故障信息", notes = "根据设备编号和时间范围查询故障信息")
    @GetMapping("/queryFaultInfo")
    public Result<List<FaultResultModel>> queryFaultInfo(@RequestParam(name = "unitCode") String unitCode,
            @RequestParam(name = "startTime") @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date startTime,
            @RequestParam(name = "endTime") @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date endTime) {
        try {
            // 参数校验
            if (unitCode == null || unitCode.trim().isEmpty()) {
                return Result.badRequest("设备编号不能为空");
            }
            if (startTime == null) {
                return Result.badRequest("开始时间不能为空");
            }
            if (endTime == null) {
                return Result.badRequest("结束时间不能为空");
            }
            if (startTime.after(endTime)) {
                return Result.badRequest("开始时间不能晚于结束时间");
            }
            
            List<FaultResultModel> faultInfo = dataReplayService.queryFaultInfo(unitCode.trim(), startTime, endTime);
            return Result.success(faultInfo);
        } catch (Exception e) {
            return Result.error("查询故障信息失败: " + e.getMessage());
        }
    }
}
